package com.rybbaby.tss.core.verifier;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @description 所有验证器抽象类
 * 
 * @author 谢进伟
 * 
 * @createDate 2016年3月29日 下午2:47:58
 */
public abstract class AbstractVerifier {
	
	/** 验证失败的提示信息 **/
	protected String errorMsg = "";
	
	/**
	 * 获取验证失败的提示信息
	 * 
	 * @return 验证失败的提示信息
	 */
	public String getErrorMsg() {
		return this.errorMsg;
	}
	
	/**
	 * 对传入参数进行验证
	 * 
	 * @param needValidateValue
	 *            需要验证的值
	 * @return
	 */
	public abstract boolean validate(Object params);
	
	/**
	 * 获取验证器注解配置的验证器
	 * 
	 * @param annotation
	 *            验证器注解
	 * @return
	 */
	public static AbstractVerifier getTargetVerifer(Annotation annotation) {
		AbstractVerifier obj = null;
		Object targetVerifier = null;
		try {
			Method verifier = annotation.getClass().getDeclaredMethod("verifier");
			if(verifier == null) {
				return obj;
			}
			targetVerifier = verifier.invoke(annotation);// 目标验证器
			obj = (AbstractVerifier)(((Class<?>)targetVerifier)).newInstance();// 初始化验证器
			if(obj != null && obj instanceof AbstractVerifier) {
				initVerifierValue(annotation , targetVerifier , obj);
			}
		} catch (Exception e) {
		}
		return obj;
	}
	
	/**
	 * 对参数进行验证
	 * 
	 * @param params
	 *            需要验证的参数
	 * @param nullable
	 *            为null时返回结果
	 * @param regexp
	 *            正则
	 * @return
	 */
	protected boolean validate(Object params , boolean nullable , String regexp) {
		return validate(params , nullable , regexp , null);
	}
	
	/**
	 * 对参数进行验证
	 * 
	 * @param params
	 *            需要验证的参数
	 * @param nullable
	 *            为null时返回结果
	 * @param regexp
	 *            正则
	 * @param validate
	 *            自定义验证规则
	 * @return
	 */
	protected boolean validate(Object params , boolean nullable , String regexp , ValidationRule validate) {
		if(params == null) {
			return nullable;
		}
		boolean result = true;
		Class<? extends Object> class1 = params.getClass();
		if(class1.isArray()) {
			Object obj [] = (Object [])params;
			for(Object object : obj) {
				if(validate != null) {
					result = validate.check(object);
				} else {
					regexp = defaultRegextp(regexp);
					result = (object + "").matches(regexp);
				}
				if(!result) {
					break;
				}
			}
		} else {
			if(validate != null) {
				result = validate.check(params);
			} else {
				regexp = defaultRegextp(regexp);
				result = (params + "").matches(regexp);
			}
		}
		return result;
	}
	
	/**
	 * 将验证器注解的值，复制给指定的验证器的指定对象
	 * 
	 * @param annotation
	 *            注解对象
	 * @param verifier
	 *            验证器类型
	 * @param obj
	 *            验证器对象
	 * @throws IllegalAccessException
	 * @throws InvocationTargetException
	 */
	private static void initVerifierValue(Object annotation , Object verifier , Object obj) throws IllegalAccessException , InvocationTargetException {
		Field [] fields = ((Class<?>)verifier).getDeclaredFields();
		Method [] annoMethods = annotation.getClass().getDeclaredMethods();
		for(Field f : fields) {
			String fieldName1 = f.getName();
			for(Method method : annoMethods) {
				String methodName = method.getName();
				if(fieldName1.equals(methodName)) {
					f.setAccessible(true);
					method.setAccessible(true);
					f.set(obj , method.invoke(annotation));
					break;
				}
			}
		}
	}
	
	private String defaultRegextp(String regexp) {
		if(regexp == null) {
			regexp = "^.*$";
		}
		return regexp;
	}
	
	/**
	 * 
	 * @description 验证规则
	 * 
	 * @author 谢进伟
	 * 
	 * @createDate 2016年3月31日 下午3:07:06
	 */
	protected static interface ValidationRule {
		
		/**
		 * 使用自定义验证规则对参数进行
		 * 
		 * @param params
		 *            需要验证的参数
		 * @return
		 */
		public abstract boolean check(Object params);
	}
}
